📄 wanda/spec.go:209

Looking at the test case "prefix$VAR1-$VAR2suffix" which expects ["VAR1", "VAR2suffix"], this suggests that variables without explicit termination (like - after VAR1) correctly stop at non-alphanumeric characters, but VAR2suffix shows that suffix is being included as part of the variable name.

This is correct behavior per the parsing logic (letters/underscores continue the variable name), but the test expectation reveals a potential usability concern: users might expect $VAR2suffix to expand $VAR2 only and leave suffix as literal text. This is an edge case worth documenting, though the behavior is internally consistent with how the parser works.

📄 wanda/spec.go:210

The expandVarWithParams function generates the cartesian product of all param combinations. With multiple variables each having many values, this could produce a very large number of combinations.

For example, with 3 variables each having 10 values, this would generate 1000 combinations. While this is likely acceptable for typical use cases (2-3 Python versions, 2 architectures), there's no upper bound or warning for unusual configurations.

Consider adding a safeguard or warning if the number of combinations exceeds a reasonable threshold (e.g., 100), to help users catch misconfiguration early:

const maxCombinations = 100
if len(combinations) > maxCombinations {
    return nil, fmt.Errorf("params generate %d combinations, exceeding limit of %d", len(combinations), maxCombinations)
}

📄 wanda/spec.go:211 📄 wanda/spec.go:156

In ValidateParams, the function iterates over s.Params map. Since Go map iteration order is non-deterministic, if multiple params have invalid values, the error message will vary between runs, potentially reporting different variables each time.

While this doesn't affect correctness (any validation failure is still a failure), it could make debugging harder since users might see different error messages for the same configuration.

Consider collecting all validation errors or sorting the keys before iteration:

func (s *Spec) ValidateParams(lookup lookupFunc) error {
    var errs []string
    for varName, allowed := range s.Params {
        val, ok := lookup(varName)
        if !ok {
            continue
        }
        valid := false
        for _, a := range allowed {
            if val == a {
                valid = true
                break
            }
        }
        if !valid {
            errs = append(errs, fmt.Sprintf("%s=%q (allowed: %v)", varName, val, allowed))
        }
    }
    if len(errs) > 0 {
        sort.Strings(errs)
        return fmt.Errorf("invalid param values: %s", strings.Join(errs, ", "))
    }
    return nil
}